A ideia principal será analisar algumas características da amostra Train disponibilizada pelo Dark Energy Survey e utilizada para treinar algoritmos. A amostra consta com dados de observações de aproximadamente 5800 galáxias.
Importando as bibliotecas que serão utilizadas
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import healpy as hp
Lendo o arquivo e definindo cor por banda em uma variável que será reaproveitada entre os gráficos
headers=[
"u_auto", "u_auto_err", "u_det", "u_det_err",
"g_auto", "g_auto_err", "g_det", "g_det_err",
"r_auto", "r_auto_err", "r_det", "r_det_err",
"i_auto", "i_auto_err", "i_det", "i_det_err",
"z_auto", "z_auto_err", "z_det", "z_det_err",
"Y_auto", "Y_auto_err", "Y_det", "Y_det_err",
"z", "ra", "dec", "z_flags", "field_id", "number"
]
banda_cor = {
"u": "r",
"g": "m",
"r": "b",
"i": "c",
"z": "g",
"Y": "y",
}
data_frame = pd.read_csv("des_sv_main_standard.train", delimiter=" ", names=headers)
Como nos foi disponibilizado as colunas de Ascendência de Reta (RA), equivalente ao eixo x no mapa celeste, e declinação (DEC), equivalente ao eixo y, podemos fazer uma associação (x,y) e localizar onde, no céu, foi coletado esses dados.
Para isso, vamos obter o valor máximo e mínimo de cada eixo e definir uma função que vai facilitar a nossa análise.
x_min = data_frame.ra.min()
x_max = data_frame.ra.max()
y_min = data_frame.dec.min()
y_max = data_frame.dec.max()
print(x_min, x_max, y_min, y_max)
35.38543249812224 210.6975180441202 -29.047361961013326 5.8582403884387695
def monta_grafico_ra_dec(x_min = (x_min-10), x_max = (x_max+10), y_min = (y_min-3), y_max = (y_max+3)):
plt.plot(data_frame.ra, data_frame.dec, f"k.", alpha=0.1)
plt.xlabel("ra", fontsize=16)
plt.ylabel("dec", fontsize=16)
plt.xticks(fontsize=16)
plt.yticks(fontsize=16)
plt.xlim(x_min, x_max)
plt.ylim(y_min, y_max)
plt.figure(figsize=[16,10], dpi=300)
plt.suptitle("RA x DEC", fontsize=18)
monta_grafico_ra_dec()
plt.tight_layout()
Para cada "boolinho", chamado de field, foi aproximado a visão, e conforme a quantidade aglomerada podemos perceber:
Um aglomerado em cada hexágono;
Acontece por conta dos dados serem a junção de amostras mapeadas distintamentes e portanto podemosver a distribuição espacial heterogênea, e conforme os dados comuns foram mais analisados acabam aparecendo mais vezes. Portanto, não são ruidos os pontos que estão fora dos aglomerados de galáxias e sim apenas galáxias mapeadas diferentes.
Uma espécie de tijolinhos formados nos aglomerados.
Causado por conta da câmera do DES, DECam. Cada tijolo é um sensor da câmera.
def monta_grafico_ra_dec(x_min, x_max, y_min, y_max):
plt.plot(data_frame.ra, data_frame.dec, f"k.", alpha=0.1)
plt.xlabel("ra", fontsize=16)
plt.ylabel("dec", fontsize=16)
plt.xticks(fontsize=16)
plt.yticks(fontsize=16)
plt.xlim(x_min, x_max)
plt.ylim(y_min, y_max)
plt.figure(figsize=[16,5], dpi=100)
plt.suptitle("localização da amostra (zoom)", fontsize=16)
plt.subplot(1,3,1)
monta_grafico_ra_dec(51.3, 54, -29.2, -27)
plt.subplot(1,3,2)
monta_grafico_ra_dec(35.3, 37.6, -5.8, -3.5)
plt.subplot(1,3,3)
monta_grafico_ra_dec(208.3, 211, 3.5, 6)
plt.xticks(fontsize=14)
plt.tight_layout()
Existem melhores formas de fazer essa query, mas a ideia aqui é ter uma noção, então, foi selecionado para cada field capturado, o ponto central, calculando a média da ascenção de reta (ra) e declinação (dec) dentro do conjunto.
medias_1 = data_frame.query("ra > 50 & ra < 75 & dec < -25").mean()
print(medias_1.ra, medias_1.dec)
medias_2 = data_frame.query("ra < 50 & dec < 0 & dec > -10").mean()
print(medias_2.ra, medias_2.dec)
medias_3 = data_frame.query("ra > 50 & dec > 0").mean()
print(medias_3.ra, medias_3.dec)
52.982684136485226 -27.914789136415074 36.615372028534296 -4.496395828915506 209.6269803400604 4.885842334037079
logo após foi, para cada média dos fields criado vetores de localização para depois conseguir mostrar no mapa.
NSIDE = 32
NPIX = hp.nside2npix(NSIDE)
vec1 = hp.ang2vec(round(medias_1.ra, 2), round(medias_1.dec,2), True)
vec2 = hp.ang2vec(round(medias_2.ra, 2), round(medias_2.dec,2), True)
vec3 = hp.ang2vec(round(medias_3.ra, 2), round(medias_3.dec,2), True)
print(vec1, vec2, vec3)
[ 0.53206059 0.7055557 -0.46808405] [ 0.80013513 0.59466625 -0.0784591 ] [-0.86607233 -0.49259755 0.08524303]
para cada vetor criado, foi selecionado todos os pontos com distancia de 1 radianos para mostrar no mapa, marcando assim a localização no céu.
ipix_disc1 = hp.query_disc(nside=NSIDE, vec=vec1, radius=np.radians(1))
ipix_disc2 = hp.query_disc(nside=NSIDE, vec=vec2, radius=np.radians(1))
ipix_disc3 = hp.query_disc(nside=NSIDE, vec=vec3, radius=np.radians(1))
m = np.arange(NPIX)
m[ipix_disc1] = m.max()
m[ipix_disc2] = m.max()
m[ipix_disc3] = m.max()
hp.projview(m,
title="Disposição amostra",
graticule=True,
graticule_labels=True,
unit="NPIX distribution",
xlabel="dec",
ylabel="ra",
projection_type="mollweide")
<matplotlib.collections.QuadMesh at 0x7f3e400f1550>
Primeiro, olhando o conteúdo separado, pode-se notar que dentro da nossa amostra total, para cada banda, existem alguns pontos com valores de erro e magnitude mais altos que a maioria dos pontos.
plt.figure(figsize=[16,10], dpi=300)
plt.suptitle("Magnitude x Erro (grizY)", fontsize=16)
pos_grafico = 1
for key, value in banda_cor.items():
plt.subplot(2,3,pos_grafico)
plt.plot(data_frame[f"{key}_auto"], data_frame[f"{key}_auto_err"], f"{value}.", alpha=0.5)
plt.xlabel(f"magnitude ({key}-band)", fontsize=14)
plt.ylabel("erro", fontsize=14)
plt.xlim(0, 120)
plt.ylim(0, 120)
plt.tight_layout()
pos_grafico = pos_grafico + 1
Podemos ver, com base nos gráficos, que, as bandas com maior erro na captura da magnitude são as bandas mais extremas u e y. Também pode-se observar que para todas as bandas existem magnitudes que extrapolam, ou estão muito próximas ao valor de 100. Olhando com mais cautela, vemos que não necessáriamente são os mesmos pontos. O que pode configurar objetos com características diferentes, por exemplo, comparando evolução em questão de idade do objeto e emissão de comprimento de onda maior em certa banda.
obs: Aqui limitamos em 5 só para conseguir ver na tabela alguns objetos com magnitude maior que 100
data_frame.query("u_auto > 100").head(5)
| u_auto | u_auto_err | u_det | u_det_err | g_auto | g_auto_err | g_det | g_det_err | r_auto | r_auto_err | ... | Y_auto | Y_auto_err | Y_det | Y_det_err | z | ra | dec | z_flags | field_id | number | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 19 | 102.300003 | 99.0 | 23.792501 | 1.094959 | 22.113060 | 0.067981 | 21.612234 | 0.048982 | 20.704815 | 0.034818 | ... | 19.116783 | 0.044421 | 18.071934 | 0.019875 | 0.624862 | 208.736428 | 5.069336 | 3.0 | 17.0 | 17382.0 |
| 22 | 102.300003 | 99.0 | 24.452652 | 0.519227 | 22.849508 | 0.075569 | 22.795902 | 0.047686 | 21.147751 | 0.024607 | ... | 19.359325 | 0.026665 | 19.119003 | 0.014577 | 0.686781 | 209.247110 | 5.088807 | 3.0 | 17.0 | 18680.0 |
| 49 | 102.300003 | 99.0 | 24.263866 | 0.954380 | 22.556496 | 0.085188 | 22.072447 | 0.043945 | 20.749512 | 0.025995 | ... | 19.287985 | 0.038688 | 18.824326 | 0.020035 | 0.523108 | 208.883578 | 5.365280 | 3.0 | 17.0 | 35941.0 |
| 62 | 102.300003 | 99.0 | 102.300003 | 99.000000 | 22.626915 | 0.072182 | 22.408995 | 0.041329 | 20.895748 | 0.021281 | ... | 19.345421 | 0.029546 | 19.046089 | 0.015663 | 0.639022 | 209.337538 | 5.472947 | 3.0 | 17.0 | 41285.0 |
| 127 | 102.300003 | 99.0 | 23.667313 | 0.389033 | 22.431358 | 0.061784 | 22.069544 | 0.031081 | 20.612705 | 0.018219 | ... | 19.254866 | 0.029120 | 18.830379 | 0.013560 | 0.543911 | 210.482173 | 5.051269 | 3.0 | 17.0 | 71019.0 |
5 rows × 30 columns
data_frame.query("Y_auto > 100").head(5)
| u_auto | u_auto_err | u_det | u_det_err | g_auto | g_auto_err | g_det | g_det_err | r_auto | r_auto_err | ... | Y_auto | Y_auto_err | Y_det | Y_det_err | z | ra | dec | z_flags | field_id | number | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 246 | 102.300003 | 99.000000 | 13.832774 | 0.194720 | 17.140846 | 0.001966 | 17.131985 | 0.001418 | 16.300085 | 0.001376 | ... | 103.180000 | 99.0 | 13.166514 | 0.110345 | 0.119883 | 208.719860 | 4.389913 | 3.0 | 17.0 | 142796.0 |
| 407 | 23.980352 | 0.253371 | 24.079817 | 0.278963 | 23.629768 | 0.069643 | 23.580387 | 0.058809 | 23.381126 | 0.056846 | ... | 102.739998 | 99.0 | 102.750000 | 99.000000 | 0.864000 | 36.362529 | -4.581767 | 3.0 | 0.0 | 974.0 |
| 408 | 23.797377 | 0.390823 | 23.330927 | 0.247650 | 23.566006 | 0.123223 | 23.029400 | 0.070499 | 22.914864 | 0.069703 | ... | 102.739998 | 99.0 | 24.188515 | 3.052163 | 0.446000 | 36.306316 | -4.579274 | 3.0 | 0.0 | 1267.0 |
| 411 | 103.150002 | 99.000000 | 103.160004 | 99.000000 | 24.145306 | 0.247125 | 22.597492 | 0.267177 | 22.035503 | 0.043067 | ... | 102.739998 | 99.0 | 102.750000 | 99.000000 | 0.666000 | 36.288581 | -4.575983 | 4.0 | 0.0 | 1650.0 |
| 414 | 24.597412 | 0.707796 | 24.317989 | 0.467922 | 24.679539 | 0.250967 | 24.415726 | 0.152045 | 23.940544 | 0.130340 | ... | 102.739998 | 99.0 | 102.750000 | 99.000000 | 0.702000 | 36.441022 | -4.572933 | 3.0 | 0.0 | 1976.0 |
5 rows × 30 columns
É interessante também reparar que os valores de erros acima ou iguais a 99 podem ter sido colocados na mão por conta de perda de valores ou valores altos.
def monta_grafico_plot(pos_grafico, key, x_min_limit, x_max_limit, y_min_limit=0, y_max_limit=100):
plt.subplot(2,3,pos_grafico)
plt.plot(data_frame[f"{key}_auto"], data_frame[f"{key}_auto_err"], f"{banda_cor.get(key)}.", alpha=0.1)
plt.xlabel(f"magnitude ({key}-band)", fontsize=14)
plt.ylabel("erro", fontsize=14)
plt.xlim(x_min_limit, x_max_limit)
plt.ylim(y_min_limit, y_max_limit)
plt.tight_layout()
plt.figure(figsize=[16,10], dpi=300)
plt.suptitle("Magnitude x Erro (grizY)", fontsize=16)
monta_grafico_plot(1, "u", 15, 30, y_max_limit=60)
monta_grafico_plot(2, "g", 14, 29, y_max_limit=6)
monta_grafico_plot(3, "r", 13, 26, y_max_limit=0.5)
monta_grafico_plot(4, "i", 12, 26, y_max_limit=1)
monta_grafico_plot(5, "z", 12, 28, y_max_limit=8)
monta_grafico_plot(6, "Y", 12, 30, y_max_limit=80)
Como maior parte dos objetos, indiferente da banda, fica entre a magnitude 20 até 25, 26. Vale a pena limitar ainda mais, tanto a magnitude quanto o erro para ver melhor a disperção dos pontos nessa faixa mais ascendente.
plt.figure(figsize=[16,10], dpi=300)
plt.suptitle("Magnitude x Erro (grizY)", fontsize=16)
monta_grafico_plot(1, "u", 18, 28, y_max_limit=5)
monta_grafico_plot(2, "g", 18, 26, y_max_limit=0.5)
monta_grafico_plot(3, "r", 18, 25, y_max_limit=0.2)
monta_grafico_plot(4, "i", 18, 25, y_max_limit=0.2)
monta_grafico_plot(5, "z", 18, 25, y_max_limit=0.5)
monta_grafico_plot(6, "Y", 18, 25, y_max_limit=3)
Analisando, podemos perceber que:
Isso se deve ao fato de as bandas mais externas serem mais dificeis de capturar e, portanto, possuiem um maior erro.
Para comparação, se adicionado em um único gráfico percebemos que no geral, a banda u e a banda Y recebem maior destaque por possuirem os maiores erros.
plt.figure(figsize=[16,10], dpi=300)
plt.suptitle("Magnitude x Erro (grizY)", fontsize=16)
for key, value in banda_cor.items():
plt.plot(data_frame[f"{key}_auto"], data_frame[f"{key}_auto_err"], f"{banda_cor.get(key)}.", alpha=0.3, label=key)
plt.xlabel(f"magnitude", fontsize=16)
plt.ylabel("erro", fontsize=16)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.xlim(16, 24)
plt.ylim(0, 0.2)
plt.legend(loc="upper left", fontsize="xx-large", markerscale=3)
plt.tight_layout()
Pode ser interessante também, plotar as bandas com menor erro separadamente. Confirmando a proximidade das bandas r e i, por possuirem os menores erros de captura.
plt.figure(figsize=[16,10], dpi=300)
plt.suptitle("Magnitude x Erro (banda r e i)", fontsize=16)
r = "r"
plt.plot(data_frame["r_auto"], data_frame["r_auto_err"], f"{banda_cor.get(r)}.", alpha=0.2, label="r")
i = "i"
plt.plot(data_frame["i_auto"], data_frame["i_auto_err"], f"{banda_cor.get(i)}.", alpha=0.2, label="i")
plt.xlabel(f"magnitude", fontsize=16)
plt.ylabel("erro", fontsize=16)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.xlim(18, 24)
plt.ylim(0, 0.1)
plt.legend(loc="upper left", fontsize="xx-large", markerscale=3)
plt.tight_layout()
Construindo um gráfico para cada banda, percebemos que a maioria dos pontos fica ali na magnitude x e y e novamente vemos o nosso ponto com valor alto aparecendo acima da magnitude 100.
def monta_grafico_hist(pos, key, x_min = 0, x_max = 120, y_min = 0, y_max = 500):
plt.subplot(2,3,pos)
plt.hist(data_frame[f"{key}_auto"], bins="fd", color=f"{banda_cor.get(key)}")
plt.xlabel(f"magnitude ({key}_band)", fontsize=16)
plt.ylabel("qtd", fontsize=16)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.xlim(x_min, x_max)
plt.ylim(y_min, y_max)
plt.tight_layout()
plt.figure(figsize=[16,10], dpi=300)
plt.suptitle("Magnitude x Quantidade (em cada banda)", fontsize=16)
pos_grafico = 1
for key, value in banda_cor.items():
monta_grafico_hist(pos_grafico, key)
pos_grafico = pos_grafico + 1
Olhando mais de perto a distribuição dos dados pode-se perceber que a maior parte da amostra fica entre 15 - 25 de magnitude
plt.figure(figsize=[16,10], dpi=150)
plt.suptitle("Magnitude x Quantidade (grizY)", fontsize=16)
monta_grafico_hist(1, "u", 18, 28, y_max = 400)
monta_grafico_hist(2, "g", 16, 26, y_max = 400)
monta_grafico_hist(3, "r", 15, 25, y_max = 450)
monta_grafico_hist(4, "i", 15, 25, y_max = 450)
monta_grafico_hist(5, "z", 15, 25, y_max = 450)
monta_grafico_hist(6, "Y", 15, 25, y_max = 450)
Para termos uma noção de quantos pontos são extremos para acima de 100, também vale a pena vê-los separados
plt.figure(figsize=[16,10], dpi=300)
plt.suptitle("Magnitude x Quantidade (grizY)", fontsize=16)
monta_grafico_hist(1, "u", 100, 110, y_max = 300)
monta_grafico_hist(2, "g", 100, 110, y_max = 50)
monta_grafico_hist(3, "r", 100, 110, y_max = 2)
monta_grafico_hist(4, "i", 100, 110, y_max = 50)
monta_grafico_hist(5, "z", 100, 110, y_max = 50)
monta_grafico_hist(6, "Y", 100, 110, y_max = 300)
Podemos perceber, com um gráfico comparativo entre todas as bandas, que:
plt.figure(figsize=[16,10], dpi=300)
plt.suptitle("Quantidade x Magnitude", fontsize=16)
for key, value in banda_cor.items():
plt.hist(data_frame[f"{key}_auto"], bins="fd", color= value, label=key, alpha=0.3, ec=value, histtype="step", lw=3)
plt.xlabel(f"magnitude", fontsize=16)
plt.ylabel("qtd", fontsize=16)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.xlim(15, 28)
plt.ylim(15, 500)
plt.legend(loc="upper left", fontsize="xx-large", markerscale=3)
plt.tight_layout()
Também podemos olhar que a nossa maior quantidade de itens com erro ficam muito próximo de zero e conforme aumenta-se a magnitude, ou seja, quanto menor o brilho aparente que o objeto tiver, o erro na sua captura vai aumentando também.
plt.figure(figsize=[16,10], dpi=300)
plt.suptitle("Quantidade x Erro", fontsize=16)
for key, value in banda_cor.items():
plt.hist(data_frame[f"{key}_auto_err"], bins="fd", label=key, alpha=0.3, ec=value, histtype="step", lw=3)
plt.xlabel(f"erro", fontsize=16)
plt.ylabel("qtd", fontsize=16)
plt.xticks(fontsize=15)
plt.yticks(ticks=[500, 1500], fontsize=15)
plt.xlim(0, 2)
plt.ylim(0, 1000)
plt.yscale("linear")
plt.legend(loc="upper right", fontsize="xx-large", markerscale=3)
plt.tight_layout()
print("Quantidade de erros acima de 100 por banda.")
for key, value in banda_cor.items():
tabela = data_frame.query(f"{key}_auto_err > 90").number.count()
print(f"{key}_band: {tabela}.")
Quantidade de erros acima de 100 por banda. u_band: 381. g_band: 23. r_band: 1. i_band: 38. z_band: 63. Y_band: 270.
data_frame.query(f"u_auto_err > 100")
| u_auto | u_auto_err | u_det | u_det_err | g_auto | g_auto_err | g_det | g_det_err | r_auto | r_auto_err | ... | Y_auto | Y_auto_err | Y_det | Y_det_err | z | ra | dec | z_flags | field_id | number | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 575 | 31.205954 | 102.804306 | 26.009026 | 1.129504 | 25.454350 | 0.227256 | 25.109772 | 0.180474 | 24.737778 | 0.125784 | ... | 102.739998 | 99.000000 | 102.750000 | 99.000000 | 0.810 | 36.386524 | -4.254266 | 3.0 | 0.0 | 31160.0 |
| 775 | 31.753345 | 322.527405 | 25.891392 | 1.204802 | 24.262344 | 0.134924 | 24.232277 | 0.089891 | 23.397869 | 0.064705 | ... | 22.226105 | 0.301082 | 22.387110 | 0.265498 | 0.427 | 36.655307 | -4.534696 | 4.0 | 0.0 | 76942.0 |
| 3261 | 32.390491 | 1203.749878 | 24.499855 | 0.698108 | 23.985622 | 0.178515 | 23.572132 | 0.090170 | 22.104448 | 0.049247 | ... | 20.308832 | 0.053217 | 19.949554 | 0.028224 | 0.764 | 210.093764 | 5.373607 | 4.0 | 6.0 | 94902.0 |
3 rows × 30 columns
Com um gráfico de quantidade por erro sendo o erros mais altos percebemos que a banda u possui mais dados que as demais com problemas na captura, visto que é a banda que é de menor capacidade de transmissão.
obs: ignoramos os erros acima de 100
plt.figure(figsize=[16,10], dpi=300)
plt.suptitle("Quantidade x Erro", fontsize=16)
for key, value in banda_cor.items():
plt.hist(data_frame[f"{key}_auto_err"], bins="fd", label=key, alpha=0.3, ec=value, histtype="step", lw=3)
plt.xlabel(f"erro", fontsize=16)
plt.ylabel("qtd", fontsize=16)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.xlim(98.9, 99.1)
plt.ylim(0, 400)
plt.yscale("linear")
plt.legend(loc="upper right", fontsize="xx-large", markerscale=3)
plt.tight_layout()
Para cada banda a razão sinal ruido pela magnitude, indica que, dado um ponto capturado, qual a chance de ele realmente ser um objeto no céu e não somente um erro de captura, visto que erros tendem a se anular conforme o erro varia. Aqui temos um para cada banda uma comparação sinal/ruido pela magnitude
def mag_sr(pos, key, x_min=15, x_max=30, y_min=0, y_max=60):
plt.subplot(2,3,pos)
plt.plot(data_frame[f"{key}_auto"], 1/data_frame[f"{key}_auto_err"], f"{banda_cor.get(key)}.", alpha=0.2, label=key)
plt.xlabel(f"magnitude ({key}_band)", fontsize=16)
plt.ylabel("S/R", fontsize=16)
plt.xticks(fontsize=16)
plt.yticks(fontsize=16)
plt.xlim(0, 40)
plt.ylim(0, 20)
plt.hlines(10, 0, 50)
plt.figure(figsize=[16,10], dpi=300)
plt.suptitle("Magnitude x Sinal Ruido (grizY)", fontsize=16)
bandas = list(banda_cor)
mag_sr(1, bandas[0], 20, 28, 0, 15)
mag_sr(2, bandas[1], 21, 27, 0, 30)
mag_sr(3, bandas[2], 21, 26, 0, 30)
mag_sr(4, bandas[3], 21, 26, 0, 30)
mag_sr(5, bandas[4], 20, 26, 0, 30)
mag_sr(6, bandas[5], 19, 26, 0, 20)
plt.tight_layout()
Cor é definido como a diferença de magnitudes entre duas bandas.

def qtd_cor(key1, key2, x_min=-1, x_max=10, y_min=0, y_max=500, x_size=16):
plt.hist(data_frame[f"{key1}_auto"]-data_frame[f"{key2}_auto"], bins="fd", alpha=0.2, label=f"{key1}-{key2}")
plt.xlabel(f"color ({key1}-{key2})", fontsize=16)
plt.ylabel("qtd", fontsize=16)
plt.xticks(fontsize=x_size)
plt.yticks(fontsize=16)
plt.xlim(x_min, x_max)
plt.ylim(y_min, y_max)
plt.vlines(0, 0, 500)
plt.figure(figsize=[16,5], dpi=300)
plt.suptitle("Quantidade x Cor", fontsize=16)
plt.subplot(1,3,1)
qtd_cor("g", "r", x_min=-0.2, x_max=2.3, y_max=450)
plt.subplot(1,3,2)
qtd_cor("r", "i", x_min=-0.5, x_max=1.5, y_max=450, x_size=12)
plt.subplot(1,3,3)
qtd_cor("i", "z", x_min=-0.5, x_max=1.0, y_max=450, x_size=15)
plt.tight_layout()
plt.figure(figsize=[16,10], dpi=300)
plt.suptitle("Cor x Quantidade", fontsize=16)
qtd_cor("g", "r", x_min=-0.2, x_max=2.3, y_max=450)
qtd_cor("r", "i", x_min=-0.5, x_max=2.3, y_max=450)
qtd_cor("i", "z", x_min=-0.5, x_max=2.3, y_max=450)
plt.legend(loc="upper right", fontsize="xx-large", markerscale=3)
plt.xlabel(f"color", fontsize=16)
plt.tight_layout()
Podemos observar que as maiores quantidades ficam acima de 0, e como diminuimos a banda r da g, isso significa que possuimos maiores magnitudes nas bandas r, i e z. Conforme estudado, magnitudes maiores significam menos brilho, e portanto, podemos concluir q os objetos são mais g, r e i.
def cor_cor(key1, key2, key3, key4, x_min=-1, x_max=10, y_min=0, y_max=500, x_size=16):
plt.plot(data_frame[f"{key1}_auto"]-data_frame[f"{key2}_auto"], data_frame[f"{key3}_auto"]-data_frame[f"{key4}_auto"], f"{banda_cor.get(key1)}.", alpha=0.2)
plt.xlabel(f"color ({key1}-{key2})", fontsize=16)
plt.ylabel(f"color ({key3}-{key4})", fontsize=16)
plt.xticks(fontsize=x_size)
plt.yticks(fontsize=16)
plt.xlim(x_min, x_max)
plt.ylim(y_min, y_max)
plt.vlines(0, -10, 10)
plt.hlines(0, -10, 10)
plt.figure(figsize=[16,10], dpi=300)
plt.suptitle("Cor x Cor", fontsize=16)
cor_cor("r", "i", "g", "r", x_min=-1, x_max=2, y_min=-0.5, y_max=5)
plt.tight_layout()
Aqui cada quadrado dividido representa que os objetos que estão dentro dessas áreas, aqui, podemos interpretar que:
plt.figure(figsize=[16,10], dpi=300)
plt.suptitle("Cor x Cor", fontsize=16)
cor_cor("i", "z", "r", "i", x_min=-1, x_max=2, y_min=-0.5, y_max=2)
plt.tight_layout()
Aqui cada quadrado dividido representa que os objetos que estão dentro dessas áreas, aqui, podemos interpretar que:
def aa(key):
ma = data_frame.query(f"{key}_auto_err > 0.09 & {key}_auto_err < 0.11")[f"{key}_auto"].max()
mi = data_frame.query(f"{key}_auto_err > 0.09 & {key}_auto_err < 0.11")[f"{key}_auto"].min()
print(round(mi,2), round(ma,2))
σ = (ma+mi)/2
print(f"{key}_band: {σ}")
print()
print("10σ value")
for banda in bandas:
aa(banda)
10σ value
--------------------------------------------------------------------------- NameError Traceback (most recent call last) /tmp/ipykernel_76/1954044794.py in <module> 1 print("10σ value") ----> 2 for banda in bandas: 3 aa(banda) NameError: name 'bandas' is not defined
plt.figure(figsize=[16,10], dpi=300)
plt.suptitle("Magnitude x Sinal Ruido (grizY)", fontsize=16)
bandas = list(banda_cor)
mag_sr(1, bandas[0], 20, 25, 9, 11)
mag_sr(2, bandas[1], 21, 25, 9, 11)
mag_sr(3, bandas[2], 21, 25, 9, 11)
mag_sr(4, bandas[3], 21, 25, 9, 11)
mag_sr(5, bandas[4], 20, 25, 9, 11)
mag_sr(6, bandas[5], 19, 25, 9, 11)
plt.tight_layout()